home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / bits / stdio.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  5KB  |  177 lines
  1. /* Optimizing macros and inline functions for stdio functions.
  2.    Copyright (C) 1998, 2000, 2001, 2004 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.  
  5.    The GNU C Library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Lesser General Public
  7.    License as published by the Free Software Foundation; either
  8.    version 2.1 of the License, or (at your option) any later version.
  9.  
  10.    The GNU C Library is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Lesser General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Lesser General Public
  16.    License along with the GNU C Library; if not, write to the Free
  17.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.    02111-1307 USA.  */
  19.  
  20. #ifndef _STDIO_H
  21. # error "Never include <bits/stdio.h> directly; use <stdio.h> instead."
  22. #endif
  23.  
  24. #ifdef __cplusplus
  25. # define __STDIO_INLINE inline
  26. #else
  27. # define __STDIO_INLINE extern __inline
  28. #endif
  29.  
  30.  
  31. #ifdef __USE_EXTERN_INLINES
  32. /* Write formatted output to stdout from argument list ARG.  */
  33. __STDIO_INLINE int
  34. vprintf (__const char *__restrict __fmt, _G_va_list __arg)
  35. {
  36.   return vfprintf (stdout, __fmt, __arg);
  37. }
  38.  
  39. /* Read a character from stdin.  */
  40. __STDIO_INLINE int
  41. getchar (void)
  42. {
  43.   return _IO_getc (stdin);
  44. }
  45.  
  46.  
  47. # if defined __USE_POSIX || defined __USE_MISC
  48. /* This is defined in POSIX.1:1996.  */
  49. __STDIO_INLINE int
  50. getc_unlocked (FILE *__fp)
  51. {
  52.   return _IO_getc_unlocked (__fp);
  53. }
  54.  
  55. /* This is defined in POSIX.1:1996.  */
  56. __STDIO_INLINE int
  57. getchar_unlocked (void)
  58. {
  59.   return _IO_getc_unlocked (stdin);
  60. }
  61. # endif    /* POSIX || misc */
  62.  
  63.  
  64. /* Write a character to stdout.  */
  65. __STDIO_INLINE int
  66. putchar (int __c)
  67. {
  68.   return _IO_putc (__c, stdout);
  69. }
  70.  
  71.  
  72. # ifdef __USE_MISC
  73. /* Faster version when locking is not necessary.  */
  74. __STDIO_INLINE int
  75. fputc_unlocked (int __c, FILE *__stream)
  76. {
  77.   return _IO_putc_unlocked (__c, __stream);
  78. }
  79. # endif /* misc */
  80.  
  81.  
  82. # if defined __USE_POSIX || defined __USE_MISC
  83. /* This is defined in POSIX.1:1996.  */
  84. __STDIO_INLINE int
  85. putc_unlocked (int __c, FILE *__stream)
  86. {
  87.   return _IO_putc_unlocked (__c, __stream);
  88. }
  89.  
  90. /* This is defined in POSIX.1:1996.  */
  91. __STDIO_INLINE int
  92. putchar_unlocked (int __c)
  93. {
  94.   return _IO_putc_unlocked (__c, stdout);
  95. }
  96. # endif    /* POSIX || misc */
  97.  
  98.  
  99. # ifdef    __USE_GNU
  100. /* Like `getdelim', but reads up to a newline.  */
  101. __STDIO_INLINE _IO_ssize_t
  102. getline (char **__lineptr, size_t *__n, FILE *__stream)
  103. {
  104.   return __getdelim (__lineptr, __n, '\n', __stream);
  105. }
  106. # endif /* GNU */
  107.  
  108.  
  109. # ifdef __USE_MISC
  110. /* Faster versions when locking is not required.  */
  111. __STDIO_INLINE int
  112. __NTH (feof_unlocked (FILE *__stream))
  113. {
  114.   return _IO_feof_unlocked (__stream);
  115. }
  116.  
  117. /* Faster versions when locking is not required.  */
  118. __STDIO_INLINE int
  119. __NTH (ferror_unlocked (FILE *__stream))
  120. {
  121.   return _IO_ferror_unlocked (__stream);
  122. }
  123. # endif /* misc */
  124.  
  125. #endif /* Use extern inlines.  */
  126.  
  127.  
  128. #if defined __USE_MISC && defined __GNUC__ && defined __OPTIMIZE__
  129. /* Perform some simple optimizations.  */
  130. # define fread_unlocked(ptr, size, n, stream) \
  131.   (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n)    \
  132.            && (size_t) (size) * (size_t) (n) <= 8              \
  133.            && (size_t) (size) != 0)                      \
  134.           ? ({ char *__ptr = (char *) (ptr);                  \
  135.                FILE *__stream = (stream);                  \
  136.                size_t __cnt;                          \
  137.                for (__cnt = (size_t) (size) * (size_t) (n);          \
  138.                 __cnt > 0; --__cnt)                      \
  139.              {                              \
  140.                int __c = _IO_getc_unlocked (__stream);          \
  141.                if (__c == EOF)                      \
  142.                  break;                          \
  143.                *__ptr++ = __c;                      \
  144.              }                              \
  145.                ((size_t) (size) * (size_t) (n) - __cnt)              \
  146.             / (size_t) (size); })                      \
  147.           : (((__builtin_constant_p (size) && (size_t) (size) == 0)   \
  148.               || (__builtin_constant_p (n) && (size_t) (n) == 0))     \
  149.             /* Evaluate all parameters once.  */              \
  150.              ? ((void) (ptr), (void) (stream), (void) (size),          \
  151.             (void) (n), (size_t) 0)                      \
  152.              : fread_unlocked (ptr, size, n, stream))))
  153.  
  154. # define fwrite_unlocked(ptr, size, n, stream) \
  155.   (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n)    \
  156.            && (size_t) (size) * (size_t) (n) <= 8              \
  157.            && (size_t) (size) != 0)                      \
  158.           ? ({ const char *__ptr = (const char *) (ptr);          \
  159.                FILE *__stream = (stream);                  \
  160.                size_t __cnt;                          \
  161.                for (__cnt = (size_t) (size) * (size_t) (n);          \
  162.                 __cnt > 0; --__cnt)                      \
  163.              if (_IO_putc_unlocked (*__ptr++, __stream) == EOF)   \
  164.                break;                          \
  165.                ((size_t) (size) * (size_t) (n) - __cnt)              \
  166.             / (size_t) (size); })                      \
  167.           : (((__builtin_constant_p (size) && (size_t) (size) == 0)   \
  168.               || (__builtin_constant_p (n) && (size_t) (n) == 0))     \
  169.             /* Evaluate all parameters once.  */              \
  170.              ? ((void) (ptr), (void) (stream), (void) (size),          \
  171.             (void) (n), (size_t) 0)                      \
  172.              : fwrite_unlocked (ptr, size, n, stream))))
  173. #endif
  174.  
  175. /* Define helper macro.  */
  176. #undef __STDIO_INLINE
  177.